/*
 * @(#)LOSDDataWarn.java 1.0.0 12/10/13 版权所有 2006-2012 LOGI 保留所有权利.
 */
package com.logi.lpromis.datawarn;

import com.logi.lpromis.analyse.AnalyseBusiModelData.BusinessModelData;
import com.logi.lpromis.interf.IDataWarn;
import com.logi.lpromis.interf.process.IDataItem;

/**
 * 记录流程数据警告类
 * 2012-10-13 James
 */
public class DataWarnAnalyse implements IDataWarn
{
	
	/**
	 * 分析业务点数据源，记录警告信息
	 * @param data  业务点数据源
	 * @author jerry.yin 2012-10-18
	 */
	public static void analyseDataItem(IDataItem data)
	{
//		LOSIDataWarn datawarn = new LOSIDataWarn();
//		// 判断引用的模型是否有效
////		HashMap<String, LOSBMTable> losbTableMap = BOMManage.getBMManage().tableMap;
////		HashMap<String, LOSBMTable> losbTablePathMap = BOMManage.getBMManage().tablePathMap;
//		String[] pathAndID = data.getDataValue().split(",");
//		if(pathAndID.length > 0)
//		{
//			String modelPath = pathAndID[0];
//			String modelID = "";
//			if (pathAndID.length > 1)
//			{
//				modelID = pathAndID[1];
//			}
//
//			boolean hasWarn = false ; //是否会产生警告信息
//			StringBuilder warnContent = new StringBuilder();  //警告信息
//			
//			//获取业务点路径
//			IBusinessManager manage = (IBusinessManager) Manage.getPartitionManage().getBusinessManage();
//			String pathSb = manage.getCatalogPath(data.);
//			IBOMManage bom = Manage.getPartitionManage().getBomManage();
//			ILOSBMTable pathTable = bom.getTable(modelPath);
//			ILOSBMTable idTable = bom.getTable(modelID);
//			if (pathTable != null && idTable == null)
//			{
//				warnContent.append("目录= "+pathSb+",警告=业务点数据源:"+data.getStrDataName()+"无法找到对应的模型ID(" + modelID + ")!");
//				hasWarn = true;
//			}
//			else if (pathTable == null && idTable != null)
//			{
//				warnContent.append("目录= "+pathSb+",警告=业务点数据源:"+data.getStrDataName()+"无法找到对应的模型PATH(" + modelPath + ")!");
//				hasWarn = true;
//			}
//			else if (pathTable == null && idTable == null)
//			{
//				warnContent.append("目录= "+pathSb+",警告=业务点数据源:"+data.getStrDataName()+"无法找到对应的模型(" + data.getStrDataValue() + ")!");
//				hasWarn = true;
//			}
//
//			if (pathTable != null || idTable != null)
//			{
//				ILOSBMTable bomTable = null;
//				if(pathTable != null)
//				{
//					bomTable = pathTable;
//				}
//				else
//				{
//					bomTable = idTable;
//				}
//				int busiDataCount = data.getObjBSubDataItemList().size();
//				// 2014-01-17 16:23:02 chris.huang 增加虚拟字段的数量
//				int modelColumnCount = bomTable.getTableColumnSize();
//
//				if (busiDataCount == modelColumnCount || busiDataCount > modelColumnCount)
//				{
//					// 记录业务模型字段
//					// LOSBMTable losbTable = losbTableMap.get(modelID);
//					HashMap<String, String> columnNameSet = bomTable.getColumnName2JDBCMap();
//					LDataSet lds = new LDataSet();
//					DataTable losbTable = lds.createTable("DesTable");
//					losbTable.createColumn(String.class, "DataItemID");
//					losbTable.createColumn(String.class, "DataItemName");
//					
//					// 获取数据源字段          2013-1-5   对模型删除的字段的数据源做处理，个人新增字段不做处理
//					ArrayList<IDataItem> dataItemList = data.getObjBSubDataItemList();
//					for (int i = 0; i < dataItemList.size(); i++)
//					{
//						LOSBDataItem losbDataItem = (LOSBDataItem)dataItemList.get(i);
//						if(losbDataItem.getIntDataType() != LOSBDataItem.DataType.TABLE && losbDataItem.isBusinessModel())
//						{
//							String dataItemName = losbDataItem.getStrDataName();
//							if (!columnNameSet.containsKey(dataItemName))
//							{
//								//警告信息: 模型已改变，不存在该字段
//								warnContent.append("目录="+pathSb+",警告=业务点数据源:"
//										+data.getStrDataName()+"模型发生变化，无法找到对应的模型字段:"+dataItemName+"!\n");
//								data.setModelUseStatus(DTModelBindType.typeBindDelete);//(4);
//								hasWarn = true;
//								
//								DataRow row = losbTable.appendRow();
//								row.setValue("DataItemID", losbDataItem.getStrBDataItemID());
//								row.setValue("DataItemName", losbDataItem.getStrDataName());
//								String[] strXml = new String[1];
//								lds.DataSetWriteXml(strXml, XmlWriteMode.IgnoreSchema);
//								datawarn.setXmlDes(strXml[0]);
//							}
//						}
//					}
//				}
//				//2013-7-5 Jerry.yin 模型同步进行了处理
//				/*else if (busiDataCount < modelColumnCount)
//				{
//					warnContent.append("目录="+pathSb+",警告=业务点数据源:"+data.getStrDataName()+"对应模型出现新增字段!\n");
//					data.setModelUseStatus(DTModelBindType.typeBindAppand);//(2);
//					hasWarn = true;
//				}*/
//			}
//			
//			if(hasWarn)
//			{
//				datawarn.setIntModelType(enuModelType.BusinessProcessType);
//				datawarn.setIntWarnType(enuWarnType.WarnTypeDataItem);
//				datawarn.setStrElementID(data.getStrBDataItemID());
//				datawarn.setStrCatalogID(data.getStrBCatalogID());
//				datawarn.setStrContent(warnContent.toString());
//				LOSIDataWarn.getWarnList().add(datawarn);
//			}
//		}
	}

	/**
	 * 分析流程数据源,记录警告信息
	 * @param data 流程数据源
	 * @param processName 流程名
	 * @author jerry.yin 2012-10-18
	 */
	public static void analyseDataItem(IDataItem data ,String processName)
	{
//		LOSIDataWarn datawarn = new LOSIDataWarn();
//		//判断引用的模型是否有效
////		HashMap<String, LOSBMTable> losbTableMap = BOMManage.getBMManage().tableMap;
////		HashMap<String, LOSBMTable> losbTablePathMap = BOMManage.getBMManage().tablePathMap;
//		
//		String[] pathAndID = data.getDataValue().split(",");
//		if(pathAndID.length == 0)
//		{
//			return;
//		}
//		String modelPath = pathAndID[0];
//		String modelID = "";
//		if (pathAndID.length > 1)
//		{
//			modelID = pathAndID[1];
//		}
//
//		boolean hasWarn = false ; //是否会产生警告信息
//		StringBuilder warnContent = new StringBuilder();  //警告信息
//		
//		IBOMManage bom = Manage.getPartitionManage().getBomManage();
//		ILOSBMTable pathTable = bom.getTable(modelPath);
//		ILOSBMTable idTable = bom.getTable(modelID);
//		
//		if(pathTable != null && idTable == null)
//		{
//			warnContent.append("流程= "+processName+",警告=流程数据源:"+data.getDataName()+" 无法找到对应的模型ID(" + modelID + ")!\n");
//			hasWarn = true;
//		}
//		else if (pathTable == null && idTable != null)
//		{
//			warnContent.append("流程= "+processName+",警告=流程数据源:"+data.getDataName()+" 无法找到对应的模型PATH(" + modelPath + ")!\n");
//			hasWarn = true;
//		}
//		else if (pathTable == null && idTable == null)
//		{
//			warnContent.append("流程= "+processName+",警告=流程数据源:"+data.getDataName()+" 无法找到对应的模型(" + data.getDataValue() + ")!\n");
//			hasWarn = true;
//		}
//		
//		if (pathTable != null || idTable != null)
//		{
//			ILOSBMTable bomTable = null;
//			if(pathTable != null)
//			{
//				bomTable = pathTable;
//			}
//			else
//			{
//				bomTable = idTable;
//			}
//			int busiDataCount = data.GetSubData().size();
//			// 2014-01-17 16:23:02 chris.huang 增加虚拟字段的数量
//			int modelColumnCount = bomTable.getTableColumnSize();
//			if (busiDataCount == modelColumnCount || busiDataCount > modelColumnCount)
//			{
//				// 记录业务模型字段
//				HashMap<String, String> columnNameSet = bomTable.getColumnName2JDBCMap();
//				LDataSet lds = new LDataSet();
//				DataTable losbTable = lds.createTable("DesTable");
//				losbTable.createColumn(String.class, "DataItemID");
//				losbTable.createColumn(String.class, "DataItemName");
//				
//				// 获取数据源字段       2013-1-5   对模型删除的字段的数据源做处理，个人新增字段不做处理
//				ArrayList<IDataItem> dataItemList = data.GetSubData();
//				for (int i = 0; i < dataItemList.size(); i++)
//				{
//					IDataItem dataItem = dataItemList.get(i);
//					IDataItem losdDataItem = (IDataItem)dataItem;
//					if(losdDataItem.getDataType() != DataType.TABLE && losdDataItem.isBusinessModel())
//					{
//						String dataItemName = dataItemList.get(i).getDataName();
//						if (!columnNameSet.containsKey(dataItemName))
//						{
//							warnContent.append("流程="+processName+",警告=流程数据源: "
//									+data.getDataName()+"模型发生变化,无法找到对应模型的字段:"+dataItemName+"!\n");
//							data.setModelUseStatus(DTModelBindType.typeBindDelete);//(4);
//							hasWarn = true;
//							
//							DataRow row = losbTable.appendRow();
//							row.setValue("DataItemID", losdDataItem.getM_strDataItemID());
//							row.setValue("DataItemName", losdDataItem.getDataName());
//							String[] strXml = new String[1];
//							lds.DataSetWriteXml(strXml, XmlWriteMode.IgnoreSchema);
//							datawarn.setXmlDes(strXml[0]);
//						}
//					}
//				}
//			}
//			//2013-7-5 Jerry.yin 模型同步进行了处理
//			/*else if (busiDataCount < modelColumnCount)
//			{
//				warnContent.append("流程="+processName+",警告=流程数据源: "+data.getDataName()+" 对应模型出现新增字段!\n");
//				data.setModelUseStatus(DTModelBindType.typeBindAppand);//(2);
//				hasWarn = true;
//			}*/
//		}
//		
//		if(hasWarn)
//		{
//			datawarn.setIntModelType(enuModelType.ProcProcessType);
//			datawarn.setIntWarnType(enuWarnType.WarnTypeDataItem);
//			datawarn.setStrElementID(data.getM_strDataItemID());
//			datawarn.setStrCatalogID(data.getM_strProcessID());
//			datawarn.setStrContent(warnContent.toString());
//			LOSIDataWarn.getWarnList().add(datawarn);
//		}
	}
	
	
		
	/**
	 * 分析使用模型与存储定义的不同
	 * 2012-10-17 James
	 * @param fullName 引用路径
	 * @param md 存储定义
	 * @param procName 处理名
	 * @return
	 * @throws Exception
	 */
	public void analyseModelData(String fullName, BusinessModelData md, String procName, String strProcID, String strType)
	{
//		try
//		{
//			LOSIDataWarn datawarn = new LOSIDataWarn();
//			// 2012-11-30 Lee 当fullName为null或者32位ID时，不验证
//			if (fullName == null || fullName.length() == 32)
//			{
//				return;
//			}
//			// 存放提示信息
//			StringBuffer sb = new StringBuffer(1024);
//			// 获得模型管理类
//			// 判断引用的模型是否有效
//			IBOMManage bmm = Manage.getPartitionManage().getBomManage();
//			ILOSBMTable bmTable = checkBMTable(bmm, md.modelName, md.modelId, sb);
//			// 2013-2-19 增加标识记录模型查询获取删除字段、新增字段非空会报错的标识
//			if (bmTable != null)
//			{
//				// 进一步判断模型与引用是否一致
//				compareModelData(bmTable, md.rootModel.subItemList, sb, 0, strType);
//			}
//			if (sb.length() > 0)
//			{
//				IBNode[] bNode = { null };
//				IProcess[] proc = { null };
//				INode[] node = { null };
//				StringBuffer beforeSB = getBeforeInfo(fullName, strProcID, procName, datawarn, bNode, proc, node);
//				datawarn.setStrContent(beforeSB.append(sb).toString());
//				LOSIDataWarn.getWarnList().add(datawarn);
//			}
//		}
//		catch (Exception e)
//		{
//			LogisLog.errorStr(e, "解析模型相关动作出错:");
//		}
	}
	
	/**
	 * 比较模型与存储使用的差别
	 * 2012-10-17 James
	 * @param bmTable 模型表
	 * @param defineList 存储使用定义
	 * @param sb 存放比较差异
	 * @param level 层次
	 * @throws Exception
	 */
//	private void compareModelData(ILOSBMTable bmTable, ArrayList<ModelDataItem> defineList, StringBuffer sb, int level, String strType)
//	{
//		HashMap<String, ILOSBMColumn> cols = bmTable.getAllColumnMap();
//		
//		//记录一致的列
//		HashMap<String, ILOSBMColumn> sameList = new HashMap<String, ILOSBMColumn>();
//		
//		//循环定义的列，把与模型一致的记录下来，删除的提示出来
//		String tableInfo = makeTableHeadMessage(bmTable, level);
//		for(ModelDataItem defData : defineList)
//		{
//			if(defData.dataType != DataType.TABLE)
//			{
//				// 如果是虚拟字段 也要记录一致
//				ILOSBMColumn col = cols.get(defData.modelName);
//				if (col != null)
//				{
//					compareModelDataTypeLength(tableInfo, defData, col, sb);
//					// 记录一致的列
//					sameList.put(defData.modelName, cols.get(defData.modelName));
//				}
//				else
//				{
//					//删除的提示出来
//					makeSBInfo(tableInfo, "字段[" + defData.modelName + "]", "被删除了\n", sb);
//				}
//			}
//		}
//		int type = LogisType.getObjectInt(strType);
//		// 2013-09-24 Lee 修正归档模型变化
//		if(type == PROCESS_TYPE.LOAD_EXP_DATA || type == PROCESS_TYPE.SAVE_EXP_DATA)
//		{
//			//分析模型中是否有新增列
//			// 总列数要加上虚拟字段
//			if(sameList.size() < cols.size())
//			{
//				//2013-2-1  如果为业务模型获取,则提示新增字段。对模型统计不做处理
//				if(type == PROCESS_TYPE.LOAD_EXP_DATA)
//				{
//					for(Entry<String, ILOSBMColumn> ent : cols.entrySet())
//					{
//						if(sameList.containsKey(ent.getKey()) == false)
//						{
//							//新增项 ent.getValue()
//							makeSBInfo(tableInfo, "新增了字段[" + ent.getValue() + "]\n", "", sb);
//						}
//					}
//				}
//				//如果为模型保存,则普通关联字段不进行提示
//				else if(type == PROCESS_TYPE.SAVE_EXP_DATA)
//				{
//					for(Entry<String, ILOSBMColumn> ent : cols.entrySet())
//					{
//						// 如果模型新增了字段，但是该字段为一般关联的关联字段，则不报错
//						if(sameList.containsKey(ent.getKey()) == false)
//						{
//							if(ent.getValue().getColumntype() == ILOSBMColumn.ColumnType.OutPutColumn 
//									&& ent.getValue().getRelationbean().getRelationtype().equals(ILOSBMRelation.RelationType.RELATE))
//							{
//								// 该情况不报错
//							}
//							else
//							{
//								//新增项 ent.getValue()
//								makeSBInfo(tableInfo, "新增了字段[" + ent.getKey() + "]\n", "", sb);
//							}
//						}
//					}
//				}
//			}
//		}
//		
//		//再专门处理子表
//		for(ModelDataItem defData : defineList)
//		{
//			if(defData.bSelect && defData.subItemList != null && defData.subItemList.size() > 0)
//			{
//				ILOSBMTable subTable = bmTable.getSubTable(defData.modelName);
//				if(subTable != null)
//				{
//					StringBuffer sbs = new StringBuffer(256);
//					compareModelData(subTable, defData.subItemList, sbs, level+1, strType);
//					if(sbs.length() > 0)
//					{
//						sb.append(sbs);
//					}
//				}
//				else
//				{
//					//提示缺少子表
//					makeSBInfo(tableInfo, "缺少字段名为[" + defData.modelName + "]的子表\n", "", sb);
//				}
//			}
//		}
//	}
	
//	private ILOSBMTable checkBMTable(IBOMManage bmm, String modelName, String modelId, StringBuffer sb)
//	{
//		// 获取业务模型
//		ILOSBMTable bmTable = bmm.getTable(modelName);
//		if (bmTable == null)
//		{
//			bmTable = bmm.getTable(modelId);
//			if (bmTable != null)
//			{
//				// 记录ID有效，路径无效
//				sb.append("模型路径(");
//				sb.append(modelName);
//				sb.append(")无效，模型ID(");
//				sb.append(modelId);
//				sb.append(")有效。\n");
//			}
//			else
//			{
//				// 记录模型已删除
//				sb.append("模型路径(");
//				sb.append(modelName);
//				sb.append(")和模型ID(");
//				sb.append(modelId);
//				sb.append(")对应的模型已不存在。\n");
//			}
//		}
//		else
//		{
//			if (bmm.getTable(modelId) != bmTable)
//			{
//				if (bmm.getTable(modelId) == null)
//				{
//					// 记录ID无效，路径有效
//					sb.append("模型路径(");
//					sb.append(modelName);
//					sb.append(")有效，模型ID(");
//					sb.append(modelId);
//					sb.append(")无效。\n");
//				}
//				else
//				{
//					// 记录ID与路径不一致
//					sb.append("模型路径(");
//					sb.append(modelName);
//					sb.append(")与模型ID(");
//					sb.append(modelId);
//					sb.append(")对应的模型不一致。\n");
//				}
//			}
//		}
//		return bmTable;
//	}
//	//2015/09/14 James 修改
//	private StringBuffer getBeforeInfo(String fullName, String strProcID, 
//			String procName, LOSIDataWarn datawarn, IBNode[] bNode, 
//			IProcess[] proc, INode[] node) throws Exception
//	{
//		// 产生提示信息
//		StringBuffer beforeSB = new StringBuffer(256);
//		String posiName = null;// 处理位置名
//		// 获得引用对象
//		if (fullName != null)
//		{
//			int index = fullName.lastIndexOf(',');
//			String bNodeAttrID = fullName.substring(index + 1);
//			if ("/业务管理".equals(fullName.substring(0, 5)))
//			{
//				// 业务节点引用
//				IBusinessManager busiManage = (IBusinessManager)Manage.getPartitionManage().getBusinessManage();
//				bNode[0] = (LOSBNode)busiManage.getBusinessNodeWithNoException(fullName);
//				if (bNode[0] == null)
//				{
//					// 如果找不到业务分类或业务点，不记录数据警告信息
//					return beforeSB;
//				}
//				IBNodeAttr bNodeAttr = bNode[0].getNodeAttr(bNodeAttrID);
//				if (bNodeAttr == null)
//				{
//					// 如果找不到业务分类或业务点，不记录数据警告信息
//					return beforeSB;
//				}
//				datawarn.setIntModelType(enuModelType.BusinessProcessType);
//				datawarn.setIntWarnType(enuWarnType.WarnTypeModelData);
//				// this.strElementID = bNodeAttr.getStrBNodeAttrID();
//				// 记录业务节点
//				datawarn.setStrElementID(bNode[0].getStrBNodeID() + "," + bNodeAttr.getStrBNodeAttrID());
//				datawarn.setStrCatalogID(bNodeAttr.getStrBCatalogID());
//				datawarn.setStrBring(strProcID);
//				posiName = LOSBNodeAttr.m_posi_name[bNodeAttr.getIntAttrName() - LOSBNodeAttr.AttrName.INIT_EXP];
//				beforeSB.append("业务点(");
//				beforeSB.append(fullName.subSequence(0, index));
//				beforeSB.append(")\n的");
//				beforeSB.append(posiName);
//				beforeSB.append("中(");
//				beforeSB.append(procName);
//				beforeSB.append(")处理引用的业务模型存在下列问题:\n");
//			}
//			else if ("/导出管理".equals(fullName.substring(0, 5)))
//			{
//				
//			}
//			else
//			{
//				// 流程节点上定义表达式的支持
//				// TODO 需要根据分区获取，目前先用默认分区处理 2015-02-14 James LOSDProcessManager procManage = LOSDProcessManager.getProcessManage();
//				LOSDProcessManager procManage = (LOSDProcessManager) Manage.getPartitionManage().getProcManage();
//				INodeAttribute attr = null;
//				String[] procNodeID = fullName.substring(0, index).split("/");
//				int off = 0;
//				if (procNodeID.length == 3)
//				{
//					off = 1;
//				}
//				try
//				{
//					proc[0] = procManage.GetProcess(procNodeID[off], false);
//				}
//				catch (Exception e)
//				{
//					// TODO: handle exception
//				}
//				if (proc[0] != null)
//				{
//					node[0] = proc[0].GetNode(procNodeID[off + 1]);
//					if (node[0] != null)
//					{
//						int sort = Integer.parseInt(bNodeAttrID);
//						if (sort < node[0].GetAttr().size())
//						{
//							attr = node[0].GetAttr().get(sort);
//						}
//					}
//					else
//					{
//						// 如果找不到流程和节点，不记录数据警告信息
//						return beforeSB;
//					}
//				}
//				else
//				{
//					// 如果找不到流程和节点，不记录数据警告信息
//					return beforeSB;
//				}
//				if (attr == null)
//				{
//					// 如果找不到流程和节点，不记录数据警告信息
//					return beforeSB;
//				}
//				datawarn.setIntModelType(enuModelType.ProcProcessType);
//				datawarn.setIntWarnType(enuWarnType.WarnTypeModelData);
//				// 记录业务节点
//				datawarn.setStrElementID(node[0].getNodeID() + "," + attr.getAttrType());
//				datawarn.setStrCatalogID(proc[0].getProcessID());
//				datawarn.setStrBring(strProcID);
//				posiName = attr.getAttrName()[attr.getAttrType()];
//				beforeSB.append("流程(");
//				beforeSB.append(proc[0].getProcessName());
//				beforeSB.append(',');
//				beforeSB.append(proc[0].getVersion());
//				beforeSB.append(")\n的节点(");
//				beforeSB.append(node[0].getNodeName());
//				beforeSB.append(")\n中的");
//				beforeSB.append(posiName);
//				beforeSB.append("表达式里(");
//				beforeSB.append(procName);
//				beforeSB.append(")处理引用的业务模型存在下列问题:\n");
//			}
//		}
//		return beforeSB;
//	}
	
	/**
	 * 需求： 模型结构变更后相关动作都要提示（包括增删字段、修改类型长度）
	 * Edouard.Zhang 2014-08-25 比对模型修改类型或者类型长度长度
	 * 
	 * @param bmTable
	 * @param defData
	 * @param col
	 * @param sb
	 * @param level
	 * @return
	 */
//	private void compareModelDataTypeLength(String tableInfo, ModelDataItem defData, ILOSBMColumn col, StringBuffer sb)
//	{
//		if (CompareUtil.DBColType.STRING.equals(col.getType()) && defData.dataType != ProcessConstant.DTDataType.typeString
//				|| CompareUtil.DBColType.INTEGER.equals(col.getType()) && defData.dataType != ProcessConstant.DTDataType.typeInt
//				|| CompareUtil.DBColType.FLOAT.equals(col.getType()) && defData.dataType != ProcessConstant.DTDataType.typeDecimal
//				|| CompareUtil.DBColType.DATE.equals(col.getType()) && defData.dataType != ProcessConstant.DTDataType.typeDate
//				|| CompareUtil.DBColType.ENUM.equals(col.getType()) && defData.dataType != ProcessConstant.DTDataType.typeString
//				|| CompareUtil.DBColType.FILE.equals(col.getType()) && defData.dataType != ProcessConstant.DTDataType.typeFile)
//		{
//			makeSBInfo(tableInfo, "字段[" + col.getName() + "]", "定义的类型(" + getColumnTypeName(col.getType()) + ")和动作里定义的类型(" + getDataTypeName(defData.dataType)
//					+ ")不一致\n", sb);
//		}
//		else if ((CompareUtil.DBColType.STRING.equals(col.getType()) || CompareUtil.DBColType.INTEGER.equals(col.getType()) || CompareUtil.DBColType.FLOAT
//				.equals(col.getType()))
//				&& !defData.dataLength.equals(col.getLength()))
//		{
//			makeSBInfo(tableInfo, "字段[" + col.getName() + "]", "的数据长度(" + col.getLength() + ")和动作里定义的数据长度(" + defData.dataLength + ")不一致\n", sb);
//		}
//	}
	
//	private static String getColumnTypeName(String columnType)
//	{
//		if(CompareUtil.DBColType.STRING.equals(columnType))
//		{
//			return "字符串";
//		}
//		else if(CompareUtil.DBColType.INTEGER.equals(columnType))
//		{
//			return "整数";
//		}
//		else if(CompareUtil.DBColType.FLOAT.equals(columnType))
//		{
//			return "浮点数";
//		}
//		else if(CompareUtil.DBColType.DATE.equals(columnType))
//		{
//			return "日期";
//		}
//		else if(CompareUtil.DBColType.BOOLEAN.equals(columnType))
//		{
//			return "布尔型";
//		}
//		else if(CompareUtil.DBColType.ENUM.equals(columnType))
//		{
//			return "枚举";
//		}
//		else if(CompareUtil.DBColType.FILE.equals(columnType))
//		{
//			return "文件";
//		}
//		return "字符串";
//	}
	
//	private static String getDataTypeName(int dataType)
//	{
//		String dataTypeName = "";
//		switch (dataType) {
//		case ProcessConstant.DTDataType.typeNull:
//			dataTypeName = "空类型";
//			break;
//		case ProcessConstant.DTDataType.typeString:
//			dataTypeName = "字符串";
//			break;
//		case ProcessConstant.DTDataType.typeDecimal:
//			dataTypeName = "浮点数";
//			break;
//		case ProcessConstant.DTDataType.typeInt:
//			dataTypeName = "整数";
//			break;
//		case ProcessConstant.DTDataType.typeDate:
//			dataTypeName = "日期";
//			break;
//		case ProcessConstant.DTDataType.typeFile:
//			dataTypeName = "文件";
//			break;
//		case ProcessConstant.DTDataType.typeRepTable:
//			dataTypeName = "重复表";
//			break;
//		case ProcessConstant.DTDataType.typeExpression:
//			dataTypeName = "表达式";
//			break;
//		case ProcessConstant.DTDataType.typeByte:
//			dataTypeName = "byte";
//			break;
//		case ProcessConstant.DTDataType.typeID:
//			dataTypeName = "ID";
//			break;
//		case ProcessConstant.DTDataType.typePID:
//			dataTypeName = "PID";
//			break;
//		default:
//			dataTypeName = "typeObject";
//			break;
//		}
//		return dataTypeName;
//	}

	/**
	 * 根据层次产生模型或子模型的提示头
	 * 2012-10-17 James
	 * @param bmTable 模型表
	 * @param sb 存放提示头
	 * @param level 层次
	 */
//	private String makeTableHeadMessage(ILOSBMTable bmTable, int level)
//	{
//		StringBuffer sb = new StringBuffer();
//		if(sb.length() == 0)
//		{
//			if(level == 0)
//			{
//				sb.append("模型(");
//			}
//			else
//			{
//				sb.append("子模型(");
//			}
//			sb.append(bmTable.getPath());
//			sb.append(")\n");
//		}
//		return sb.toString();
//	}
	
	/**
	 * 分析使用模型与存储定义的不同 + 数据源与存储定义的不同 (根据ID判断) 
	 * Edouard.Zhang 2014-05-22
	 * @param fullName 引用路径
	 * @param md 存储定义
	 * @param procName 处理名
	 * @return
	 * @throws Exception
	 */
	public void analyseModelDataNew(String fullName, BusinessModelData md, String procName, String strProcID, String strType)
	{
//		try
//		{
//			LOSIDataWarn datawarn = new LOSIDataWarn();
//			// 2012-11-30 Lee 当fullName为null或者32位ID时，不验证
//			if (fullName == null || fullName.length() == 32)
//			{
//				return;
//			}
//			// 存放提示信息
//			StringBuffer sb = new StringBuffer();
//			IBOMManage bmm = Manage.getPartitionManage().getBomManage();
//			ILOSBMTable bmTable = checkBMTable(bmm, md.modelName, md.modelId, sb);
//			
//			IBNode[] bNode = { null };
//			IProcess[] proc = { null };
//			INode[] node = { null };
//			StringBuffer beforeSB = getBeforeInfo(fullName, strProcID, procName, datawarn, bNode, proc, node);
//			if (bmTable != null && (bNode[0] != null || proc[0] != null))
//			{
//				// 进一步判断模型与引用是否一致
//				compareModelDataNew(bmTable, md.rootModel, sb, 0, strType, bNode[0], proc[0], node[0]);
//			}
//			if (sb.length() > 0)
//			{
//				datawarn.setStrContent(beforeSB.append(sb).toString());
//				LOSIDataWarn.getWarnList().add(datawarn);
//			}
//		}
//		catch (Exception e)
//		{
//			LogisLog.errorStr(e, "解析模型相关动作出错:");
//		}
	}
	
//	private void compareModelDataNew(ILOSBMTable bmTable, ModelDataItem model, 
//			StringBuffer sb, int level, String strType,IBNode bNode,IProcess proc,INode node) throws Exception
//	{
//		// <模型ID,<数据源id,数据源name>>
//		HashMap<String, HashMap<String, String>>  modelIdNameMap = new HashMap<String, HashMap<String,String>>();
//		// <模型ID,<数据源name,数据源id>>
//		HashMap<String, HashMap<String, String>>  modelNameIdMap = new HashMap<String, HashMap<String,String>>();
//		if(bNode!=null)
//		{
//			 bNode.getObjBCatalog().getObjContent().getDataItemIdName(modelIdNameMap,modelNameIdMap);
//		}
//		else if(proc != null && node != null)
//		{
//			proc.getDataItemIdName(node.getNodeID(),modelIdNameMap,modelNameIdMap);
//		}
//		compareModelDataNewSub(bmTable, model, sb, level, strType, modelIdNameMap, modelNameIdMap);
//	}
	
	/**
	 * 比较模型与存储使用的差别 + 数据源与存储的差别(新)
	 * Edouard.Zhang 2014-05-22 根据ID比较
	 * @param bmTable 模型表
	 * @param defineList 存储使用定义
	 * @param sb 存放比较差异
	 * @param level 层次
	 * @throws Exception
	 */
//	private void compareModelDataNewSub(ILOSBMTable bmTable, ModelDataItem model, StringBuffer sb, int level, String strType,
//			HashMap<String, HashMap<String, String>> dataItemIdNameMap, HashMap<String, HashMap<String, String>> dataItemNameIdMap) throws Exception
//	{
//		ArrayList<ModelDataItem> defineList = model.subItemList;
//		ArrayList<ModelDataFilter> delfilterList = model.delFilter;
//		ArrayList<ModelDataFilter> filterList = model.selFilter;
//		ArrayList<String [] > ordeList = model.order;
//		
//		HashMap<String, ILOSBMColumn> idCols = bmTable.getAllColumnMap();
//		HashMap<String, ILOSBMColumn> nameCols = new HashMap<String, ILOSBMColumn>();
//		// 模型字段Map key:id value:name
//		HashMap<String, String> colIDNames = new HashMap<String, String>();		
//		// 模型字段Map key:name value:id
//		HashMap<String, String> colNameIDs = new HashMap<String, String>();
//		convertMap(idCols, nameCols, colIDNames, colNameIDs);
//
//		// <数据源id,数据源name>
//		HashMap<String,String> dataIdNameMap = dataItemIdNameMap.get(model.dataId);
//		// <数据源name,数据源id>
//		HashMap<String,String> dataNameIdMap = dataItemNameIdMap.get(model.dataId);
//		
//
//		// 记录一致的列
//		HashMap<String, ILOSBMColumn> sameList = new HashMap<String, ILOSBMColumn>();
//		// 循环定义的列，把与模型一致的记录下来，更改的,删除的提示出来 | 数据源更改的,删除的提示出来
//		String tableInfo = makeTableHeadMessage(bmTable, level);
//		String dataItemInfo = "数据源(" + model.dataName + ")\n";
//		for (ModelDataItem defData : defineList)
//		{
//			if (defData.dataType != DataType.TABLE)
//			{
//				if(defData.bSelect)
//				{
//					// 1. ID取不到 --> 模型字段被删除
//					// 2. ID取得到, Name取不到 --> 模型字段被改名
//					// 循环定义的列，把与模型一致的记录下来，删除的提示出来
//					// 先判断ID是否存在
//					String name = colIDNames.get(defData.modelId);
//					String id = colNameIDs.get(defData.modelName);
//					String colInfo = "字段名[" + defData.modelName + "]";
//					if(name == null)
//					{
//						// 模型字段被删除
//						makeSBInfo(tableInfo, colInfo, "被删除了\n", sb);
//					}
//					else if(id == null)
//					{
//						// 模型字段被删除
//						makeSBInfo(tableInfo, colInfo, "被修改成[" + name + "]\n", sb);
//					}
//					else
//					{
//						if (id.equals(defData.modelId) == false)
//						{
//							// 数据源字段被修改
//							makeSBInfo(tableInfo, colInfo, "的ID发生了变化!\n", sb);
//						}
//						else if (name.equals(defData.modelName) == false)
//						{
//							// 数据源字段被修改
//							makeSBInfo(tableInfo, colInfo, "的名称发生了变化!\n", sb);
//						}
//						else
//						{
//							ILOSBMColumn col = nameCols.get(defData.modelName);
//							if(col != null)
//							{
//								compareModelDataTypeLength(tableInfo, defData, col, sb);
//								// 记录一致的列
//								sameList.put(defData.modelId, col);
//							}
//						}
//					}
//					
//					// 1. ID取不到 --> 数据源字段被删除
//					// 2. ID取得到, Name取不到 --> 数据源字段被改名
//					if(defData.dataType == 1)
//					{
//						colInfo = "数据源[" + defData.dataName + "]";
//						checkCol(dataItemInfo, colInfo, dataIdNameMap, dataNameIdMap, defData.dataId, defData.dataName, sb);
//					}
//				}
//			}
//		}
//		// 增加字段情况处理
//		int type = LogisType.getObjectInt(strType);
//		if (type == PROCESS_TYPE.LOAD_EXP_DATA || type == PROCESS_TYPE.SAVE_EXP_DATA)
//		{
//			// 2013-2-1 如果为业务模型获取,则提示新增字段。对模型统计不做处理
//			if (type == PROCESS_TYPE.LOAD_EXP_DATA)
//			{
//				for (Entry<String, String> ent : colIDNames.entrySet())
//				{
//					if (sameList.containsKey(ent.getKey()) == false)
//					{
//						makeSBInfo(tableInfo, "新增了字段[" + ent.getValue() + "]\n", "", sb);
//					}
//				}
//			}
//			// 如果为模型保存,则普通关联字段不进行提示
//			else if (type == PROCESS_TYPE.SAVE_EXP_DATA)
//			{
//				for (Entry<String, ILOSBMColumn> ent : idCols.entrySet())
//				{
//					// 如果模型新增了字段，但是该字段为一般关联的关联字段，则不报错
//					if (sameList.containsKey(ent.getKey()) == false)
//					{
//						if (ent.getValue().getColumntype() == ILOSBMColumn.ColumnType.OutPutColumn
//								&& ent.getValue().getRelationbean().getRelationtype().equals(ILOSBMRelation.RelationType.RELATE))
//						{
//							// 该情况不报错
//						}
//						else
//						{
//							// 新增项 ent.getValue()
//							makeSBInfo(tableInfo, "新增了字段[" + ent.getValue().getName() + "]\n", "", sb);
//						}
//					}
//				}
//			}
//		}
//
//		// 分析过滤条件
//		if (delfilterList != null)
//		{
//			for (ModelDataFilter filter : delfilterList)
//			{
//				String[] fieldType = filter.fieldType.split(",");
//				// 过滤条件左值为列名
//				if (fieldType.length >= 1 && "5".equals(fieldType[0]))
//				{
//					String colInfo = "删除条件左值不正确:列名[" +  filter.fieldName + "]";
//					checkCol(tableInfo, colInfo, colIDNames, colNameIDs, filter.fieldId, filter.fieldName, sb);
//				}
//				// 过滤条件右值为列名
//				if (filter.dataType == 5)
//				{
//					String colInfo = "删除条件右值不正确:列名[" +  filter.strData + "]";
//					checkCol(tableInfo, colInfo, colIDNames, colNameIDs, filter.dataId, filter.strData, sb);
//				}
//				// 李锦说 过滤条件右值为变量时暂时不管
//			}
//		}
//		// 分析过滤条件
//		if (filterList != null)
//		{
//			for (ModelDataFilter filter : filterList)
//			{
//				String[] fieldType = filter.fieldType.split(",");
//				// 过滤条件左值为列名
//				if (fieldType.length >= 1 && "5".equals(fieldType[0]))
//				{
//					String colInfo = "过滤条件左值不正确:列名[" +  filter.fieldName + "]";
//					checkCol(tableInfo, colInfo, colIDNames, colNameIDs, filter.fieldId, filter.fieldName, sb);
//				}
//				// 过滤条件右值为列名
//				if (filter.dataType == 5)
//				{
//					String colInfo = "过滤条件右值不正确:列名[" +  filter.strData + "]";
//					checkCol(tableInfo, colInfo, colIDNames, colNameIDs, filter.dataId, filter.strData, sb);
//				}
//			}
//		}
//		if (ordeList != null)
//		{
//			for (String[] strArray : ordeList)
//			{
//				if (strArray.length == 4)
//				{
//					String colInfo = "排序条件不正确:列名[" +  strArray[0] + "]";
//					checkCol(tableInfo, colInfo, colIDNames, colNameIDs, strArray[3], strArray[0], sb);
//				}
//			}
//		}
//
//		// 再专门处理子表
//		for (ModelDataItem defData : defineList)
//		{
//			if (defData.bSelect && defData.subItemList != null && defData.subItemList.size() > 0)
//			{
//				ILOSBMTable subTable = bmTable.getSubTable(defData.modelName);
//				if (subTable != null)
//				{
//					StringBuffer sbs = new StringBuffer(256);
//					compareModelDataNewSub(subTable, defData, sbs, level + 1, strType, dataItemIdNameMap, dataItemNameIdMap);
//					if (sbs.length() > 0)
//					{
//						sb.append(sbs);
//					}
//				}
//				else
//				{	
//					// 提示缺少子表
//					makeSBInfo(tableInfo, "缺少字段名[" + defData.modelName + "]的子表\n", "", sb);
//				}
//			}
//		}
//	}
//	
//	private void convertMap(HashMap<String, ILOSBMColumn> idCols, HashMap<String, ILOSBMColumn> nameCols, HashMap<String, String> colIDNames,
//			HashMap<String, String> colNameIDs)
//	{
//		for (Entry<String, ILOSBMColumn> entry : idCols.entrySet())
//		{
//			String id = entry.getKey();
//			ILOSBMColumn column = entry.getValue();
//			String name = column.getName();
//			nameCols.put(name, column);
//			colIDNames.put(id, name);
//			colNameIDs.put(name, id);
//		}
//	}
//
//	private void checkCol(String tableInfo, String colInfo, HashMap<String, String> colIds, HashMap<String, String> colNames, String colID, String colName,
//			StringBuffer sb)
//	{
//		String name = colIds.get(colID);
//		String id = colNames.get(colName);
//		if (name == null)
//		{
//			// 模型字段被删除
//			makeSBInfo(tableInfo, colInfo, "被删除了\n", sb);
//		}
//		else if (id == null)
//		{
//			// 模型字段被改名
//			makeSBInfo(tableInfo, colInfo, "被修改成[" + name + "]\n", sb);
//		}
//		else
//		{
//			// 不报错
//			if (id.equals(colID) == false)
//			{
//				// 数据源字段被修改
//				makeSBInfo(tableInfo, colInfo, "的模型ID被修改了\n", sb);
//			}
//			else if (name.equals(colName) == false)
//			{
//				// 数据源字段被修改
//				makeSBInfo(tableInfo, colInfo, "的名称被修改为[" + name + "]了\n", sb);
//			}
//			else
//			{
//
//			}
//		}
//	}
//
//	private void makeSBInfo(String tableInfo, String colInfo, String info, StringBuffer sb)
//	{
//		sb.append(tableInfo);
//		sb.append(colInfo);
//		sb.append(info);
//	}

}
